SpatialFear.SFWindow

//=============================================================================
// Spatial Fear
// Name: SFWindow
// Description: Abstract base class for Spatial Fear  output windows.
//
// Author: Markus Nuebel
//=============================================================================


class SFWindow extends SFObject
abstract;

const constScreenMaxX     = 1280;
const constScreenMaxY     = 1024;

enum ESlideDir
{
     SLIDE_Up,
     SLIDE_Down,
     SLIDE_Left,
     SLIDE_Right,
};

enum EState
{
     SLIDE_In,
     SLIDE_Out,
     In,
     Out,
};

struct Region
{
     var() int X;
     var() int Y;
     var() int W;
     var() int H;
};


var Pawn m_oPawnOwner;	// Private: Pawn currently managing this window
var SFFontInfo m_Fonts; // Private; Font factory
var Texture m_texBkg; // Private: Window texture background
var bool	m_bVisible; // Private: Enables/Disables rendering of the window
var float   m_fHUDScale; // Private: current HUD scale. Depends on screen resolution and user defined HUD size.
var float	m_fVHUDScale; // Private: Correction of ChallengeHUD bug;
var int     m_X; // Private destination window position x
var int     m_Y; // Private destination window position y
var int     m_nWidth;  // Private: width
var int		m_nHeight; // Private: height
var int		m_fAspectRatio; // Private: aspect ratio of the window
var int     m_nWidthScaled;  // Private: width (scaled)
var int		m_nHeightScaled; // Private: height (scaled)
var int		m_nBorderSizeScaled; // Private: border size (scaled)
var int		m_nStepCur; // Private current sliding step
var int     m_nSlideTime; // Private: Time it takes to slide the window in. Time in msecs. Default: 1000msecs.
var int     m_nTimerInterval; // Private: timer interval for slide in/out actions
var float     m_XCur; // Private current window position x
var float     m_YCur; // Private current window position y
var float     m_XCurScaled; // Private current window position x (scaled)
var float     m_YCurScaled; // Private current window position y (scaled)
var float     m_fXStep; // Privat: Size of sliding step for x direction
var float     m_fYStep; // Privat: Size of sliding step for y direction
var int		m_nSlideSteps; // Private: Number of steps, needed to slide in the window
var EState	m_nState; // Private: Current slide action, in/out
var int		m_nBorderSize; // Private: Size of border
var int		m_nBkgTopOffset;	// Private: Offset of the top of the background.
var SFWindow	m_wndParent;	// Private: Parent window
var Sound	m_sndOpen;	// Private: Sound effect for opening window
var Sound	m_sndClose;	// Private: Sound effect for closing window
var float	m_fOpenSoundVol; // Volume of opening sound
var float	m_fCloseSoundVol; // Volume of closing sound

// All initialization stuff
simulated function init(float fHUDScale, int X, int Y, int nWidth, int nHeight, optional Pawn Owner, optional string strText, optional SFWindow wndParent)
{
      // Setup font factory
//      m_Fonts = FontInfo(spawn(Class<Actor>(DynamicLoadObject("Botpack.FontInfo", class'Class'))));
     m_Fonts	= spawn(class<SFFontInfo>(DynamicLoadObject("SpatialFear.SFFontInfo", class'Class')));

      // Init some members
      m_fHUDScale       = fHUDScale;
      m_X               = X;
      m_Y               = Y;
      m_XCur            = m_X;
      m_YCur            = m_Y;
      m_nWidth          = nWidth;
      m_nHeight         = nHeight;
	  m_fAspectRatio	= m_nWidth/m_nHeight;
      m_nState          = Out;
	  m_oPawnOwner		= Owner;
      m_wndParent       = wndParent;
}

// Cleanup
simulated function terminate()
{
	m_Fonts			= None;
	m_oPawnOwner	= None;
	m_wndParent		= None;
}

// Set the parent window
simulated function setParent(SFWindow oParent)
{
	m_wndParent	= oParent;
}

// Shows the window
simulated function show()
{
	m_bVisible    = true;
	if(None != m_sndOpen)
		if(None != m_oPawnOwner)
			m_oPawnOwner.PlaySound(m_sndOpen, SLOT_Misc, m_fOpenSoundVol);
		else
			PlaySound(m_sndOpen, SLOT_Misc, m_fOpenSoundVol);
}

// Hides the window
simulated function hide()
{
	if(None != m_sndClose)
		if(None != m_oPawnOwner)
			m_oPawnOwner.PlaySound(m_sndClose, SLOT_Misc, m_fCloseSoundVol);
		else
			PlaySound(m_sndClose, SLOT_Misc, m_fCloseSoundVol);

	m_bVisible    = false;
}

// Get visible state
simulated function bool isVisible()
{
          return m_bVisible;
}

// Sets a new position
simulated function setPos(int X, int Y)
{
	m_XCur	= X;;
	m_YCur	= Y;
}

// Slides in the text window
simulated function slideIn(ESlideDir slide)
{

     m_nSlideSteps     = m_nSlideTime / 100;

     // Set the initial starting position, out of the screen boundaries.
     switch(slide)
     {
     case SLIDE_Up:
          //class'sfUtils'.static.sfLogEx(5, "SFWindow - slideIn - UP");
          m_YCur               = constScreenMaxY +2;     // below screen
          m_XCur               = m_X;
          m_fXStep          = 0;
          m_fYStep          = (m_Y - m_YCur) / m_nSlideSteps     ;
          break;
     case SLIDE_Down:
          //class'sfUtils'.static.sfLogEx(5, "SFWindow - slideIn - DOWN");
          m_YCur               = -m_nHeight-2;               // above screen
          m_XCur               = m_X;
          m_fXStep          = 0;
          m_fYStep          = (m_Y - m_YCur) / m_nSlideSteps     ;
          break;
     case SLIDE_Left:
          //class'sfUtils'.static.sfLogEx(5, "SFWindow - slideIn - LEFT");
          m_XCur               = constScreenMaxX +2;     // right out of screen
          m_YCur               = m_Y;
          m_fXStep          = (m_X - m_XCur) / m_nSlideSteps     ;
          m_fYStep          = 0;
          break;
     case SLIDE_Right:
          //class'sfUtils'.static.sfLogEx(5, "SFWindow - slideIn - RIGHT");
          m_XCur               = -m_nWidth-2;               // left out of screen
          m_YCur               = m_Y;
          m_fXStep          = (m_X - m_XCur) / m_nSlideSteps;
          m_fYStep          = 0;
          break;
     }

     // Update state
     m_nState          = SLIDE_In;
     m_nStepCur          = 0;

     // class'sfUtils'.static.sfLogEx(5, "SFWindow - slideIn - SliderSteps " $ m_nSlideSteps $ " XStep " $ m_fXStep $  "YStep" $ m_fYStep);

     // Start the timer
     SetTimer(0.1, True);

     // Shows the window
     show();

}

// Overwritten in child class, to do different backgrounds and effects
simulated function renderBackground(Canvas C)
{
	local int	X, Y, W, H;
	local int	nXBorder, nYBorder;

	if(None == m_texBkg)
		return;

	// Calculate border sizes
	nXBorder	= m_nBorderSizeScaled;
	nYBorder	= int(float(nXBorder) / m_fAspectRatio);

    //class'SfUtils'.static.sfLogEx(5, "SFWindow - renderBackground: Tex.U" $  m_texBkg.USize $ " Tex.V" $  m_texBkg.VSize $  " Width" $ m_nWidth $  " Height" $ m_nHeight);
	X = m_XCurScaled-nXBorder;
	Y = m_YCurScaled-nYBorder-(m_nBkgTopOffset*m_fHUDScale);
	W = m_nWidthScaled+2*nXBorder;
	H = m_nHeightScaled+2*nYBorder+(m_nBkgTopOffset*m_fHUDScale);

	C.SetPos(X, Y);
	C.DrawTile(m_texBkg, W, H, 0,0, m_texBkg.USize,m_texBkg.VSize);
    //class'SfUtils'.static.sfLogEx(5, "SFWindow - renderBackground: X" $  m_XCurScaled $ " Y" $ m_YCurScaled $  " Width" $ m_nWidthScaled $  " Height" $ m_nHeightScaled);

}

// Overwritten in child class, to do different forground
simulated function renderForeground(Canvas C)
{
}

// Owerwritten in child class to set up the canvas
simulated function prepareCanvas(Canvas C)
{
}


// Called during each frame to render the window.
simulated final function render(Canvas C, float fHUDScale)
{
	local Color	m_colSave;

    if(!m_bVisible)
          return;          // Early out

	// Save hud scaling
	m_fHUDScale		= fHUDScale;
	// Calc scaled window positions and size
	m_XCurScaled	= m_XCur * m_fHUDScale;
	m_YCurScaled	= m_YCur * m_fHUDScale;
	m_nWidthScaled	= m_nWidth	* m_fHUDScale;
	m_nHeightScaled	= m_nHeight	* m_fHUDScale;
	m_nBorderSizeScaled	= m_nBorderSize * m_fHUDScale;

	m_fVHUDScale = ((m_fHUDScale/C.ClipX*1280.0)*C.ClipY)/1024.0f;

	// Save the original Canvas
	m_colSave = C.DrawColor;

	// Prepare canvas for output
     prepareCanvas(C);

	// First render background
	renderBackGround(C);

   // Then render foreground
	renderForeGround(C);

	// Restore the old canvas
	C.DrawColor = m_colSave ;
}


// Timer event
event Timer()
{
     // Check the timer
     if((m_nSlideSteps-1)<m_nStepCur)
     {
          SetTimer(0, False);
          m_nState = In;
          return;
     }

     // Check state
     switch(m_nState)
     {
     case SLIDE_In:
          // Move the window on step further
          m_YCur     += m_fYStep;
          m_XCur     += m_fXStep;
          break;

     case SLIDE_Out:
          // Move the window on step back
          m_YCur     -= m_fYStep;
          m_XCur     -= m_fXStep;
          break;
     }

     m_nStepCur++;
     // Check for finished movement


     // class'sfUtils'.static.sfLogEx(5, "SFWindow - Timer: x:" $ m_XCur $ " y: " $ m_YCur $ "m_nStepCur " $ m_nStepCur);

}

simulated function DrawClippedActor( Canvas C, float XB, float YB, float X, float Y, Actor A, bool WireFrame, rotator RotOffset, vector LocOffset )
{
     local vector MeshLoc;
     local float FOV;
	 local float fWidth;

	 if(None != m_oPawnOwner)
		FOV = PlayerPawn(m_oPawnOwner).FOVAngle * Pi / 180;
	 else
	     class'sfUtils'.static.sfError( "SFWindow - DrawClippedActor: window owner not set!");

	fWidth = 2.0 + (A.CollisionRadius/10);
	MeshLoc.X = fWidth / tan(FOV/2);

	//MeshLoc.X = 4 / tan(FOV/2);
     MeshLoc.Y = 0;
     MeshLoc.Z = 0;

     A.SetRotation(RotOffset);
     A.SetLocation(MeshLoc + LocOffset);

	 C.DrawClippedActor(A, WireFrame, X, Y, XB, YB, True);
}

// Trims spaces from a string
function String TrimSpaces(String strText)
{
	local int nIndex;
	local int nLength;

	if ( strText == "" )
		return strText;

	// Trim appended spaces
	nIndex = Len(strText) - 1;
	while ((nIndex >= 0) && (Mid(strText, nIndex, 1) == " ") )
		nIndex--;

	if ( nIndex < 0 )
		return "";

	// Remove appended spaces
	strText = Mid(strText, 0, nIndex + 1);

	// Trim leading spaces
	nIndex = 0;
	while((nIndex < Len(strText) - 1) && (Mid(strText, nIndex, 1) == " "))
		nIndex++;

	// Remove leading spaces
	nLength = len(strText) - nIndex;
	strText = Right(strText, nLength);

	return strText;
}

defaultproperties
{
     m_nSlideTime=1000
     m_fOpenSoundVol=2.000000
     m_fCloseSoundVol=2.000000
}